// Source file:
// G:\\5o_ano\\PCS2040\\desenvolvimento\\rose\\Servidor\\Roteamento\\Principal.java

package servidor.roteamento;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import java.sql.SQLException;

import comum.Localizacao;

public class Principal {

	private static final double CUSTO_MAXIMO = Integer.MAX_VALUE;

	private static final int MAXIMO_RESTRICOES = 3;

	Collection grafoHierarquico;

	/**
	 * @roseuid 426D7C4E00EA
	 */
	 // para funcionar com o BD descomente isto
	//public Principal() throws SQLException {
	public Principal() {
	    System.out.println("Carregando o grafo...");
	    // Alterado por Andre Romero
		
		// para funcionar com o BD descomente isto
		//try{		
		//	GrafoLoaderFromDB loader = new GrafoLoaderFromDB();
		//	grafoHierarquico = loader.load();
		//}
		//catch (SQLException e){			
		//	throw e;
		//}				
		
		// para funcionar com o BD comente isto	
		GrafoLoader loader = new GrafoLoader("/romeroWorkspace/WAI2008/GuiaMenos/src/util/POLI.xml");
		grafoHierarquico = loader.load();
		
		
		System.out.println("Grafo carregado! Pr�-calculando caminhos...");
		precalcularCaminhos();
		System.out.println("Caminhos pr�-calculados com sucesso!");
	}

	/**
	 * @param verticeInicial
	 * @param verticeFinal
	 * @return servidor.roteamento.Caminho
	 * @roseuid 4262D87500EA
	 */
	public Caminho buscarCaminhoHierarquico(Vertice verticeInicial, Vertice verticeFinal, int restricao) {

		int ls, lg, lsg;
		Caminho caminhoAux;
		Collection caminhos1, caminhos2, caminhos3;

		// Se o v�rtice inicial e final est�o num mesmo submapa
		if (verticeInicial.getSubMapaPai() == verticeFinal.getSubMapaPai()) {
			return buscarCaminho(verticeInicial, verticeFinal, restricao);
		}

		ls = verticeInicial.getNivelHierarquico();
		lg = verticeFinal.getNivelHierarquico();

		if (ls > lg) { // Se o v�rtice inicial est� num n�vel da hierarquia mais
			// profundo
			caminhos1 = getEsqueletos(verticeInicial, lg, restricao);
			caminhoAux = new Caminho();
			caminhoAux.add(verticeFinal, 0);
			caminhos2 = new ArrayList();
			caminhos2.add(caminhoAux);
		} else if (ls < lg) { // Se o v�rtice final est� num n�vel da hierarquia
			// mais profundo
			caminhos1 = getEsqueletos(verticeFinal, ls, restricao);
			caminhoAux = new Caminho();
			caminhoAux.add(verticeInicial, 0);
			caminhos2 = new ArrayList();
			caminhos2.add(caminhoAux);
		} else { // Se o v�rtice inicial e o final est�o num mesmo n�vel da
			// hierarquia
			lsg = primeiroNivelComum(verticeInicial, verticeFinal);
			caminhos1 = getEsqueletos(verticeInicial, lsg, restricao);
			caminhos2 = getEsqueletos(verticeFinal, lsg, restricao);
		}
		caminhos3 = conectarEsqueletos(caminhos1, caminhos2, restricao);
		return completarMelhorEsqueleto(caminhos3, restricao);
	}

	/**
	 * @param VerticeInicial
	 * @param verticeFinal
	 * @return servidor.roteamento.Caminho
	 * @roseuid 4262CAB103A9
	 */
	public Caminho buscarCaminho(Vertice verticeInicial, Vertice verticeFinal, int restricao) {
		return verticeInicial.getGrafoQueContem().busca(verticeInicial, verticeFinal, restricao);
	}

	/**
	 * @param verticeInicial
	 * @param nivelHierarquicoDestino
	 * @roseuid 4262CAAB00BB
	 */
	public Collection getEsqueletos(Vertice verticeInicial, int nivelHierarquicoDestino, int restricao) {
		VerticeSubMapa submapaAtual;
		Collection caminhos;

		submapaAtual = verticeInicial.getSubMapaPai();
		caminhos = estimarCaminhos(verticeInicial, submapaAtual.getVerticesPontes());
		while (submapaAtual.getNivelHierarquico() > nivelHierarquicoDestino) {
			System.out.println("ops");
			Collection caminhosNovo = new ArrayList();
			for (Iterator iter = submapaAtual.getVerticesPontes().iterator(); iter.hasNext();) {
				Vertice verticeI = (Vertice) iter.next();
				Caminho caminhoI = new Caminho();
				caminhoI.add((Vertice) null, CUSTO_MAXIMO); // inicializar caminho com custo m�ximo
				for (Iterator iterator = caminhos.iterator(); iterator.hasNext();) {
					Caminho caminhoJ = (Caminho) iterator.next();
					Caminho caminhoX = new Caminho(caminhoJ);
					Caminho temp = submapaAtual.caminhoPreCalculado(caminhoJ.getFinal(), verticeI, restricao);
					caminhoX.add(temp.getVertices(), temp.getCusto());
					if (caminhoX.getCusto() < caminhoI.getCusto()) {
						caminhoI = caminhoX;
					}
				}
				caminhosNovo.add(caminhoI);
			}
			caminhos = caminhosNovo;
			submapaAtual = submapaAtual.getSubMapaPai();
		}

		return caminhos;
	}

	/**
	 * @param verticeInicial
	 * @param verticeDestino
	 * @return Integer
	 * @roseuid 4262CAC602DE
	 */
	public int primeiroNivelComum(Vertice verticeInicial, Vertice verticeDestino) {
		int nivel = verticeInicial.getNivelHierarquico();
		VerticeSubMapa v1 = verticeInicial.getSubMapaPai();
		VerticeSubMapa v2 = verticeDestino.getSubMapaPai();

		if (v1 == v2) {
			System.err.println("ERRO");
		}

		while (nivel > 0) {
			nivel--;
			v1 = v1.getSubMapaPai();
			v2 = v2.getSubMapaPai();
			if (v1 == v2)
				break;
		}
		return nivel;
	}

	/**
	 * @param caminhos1
	 * @param caminhos2
	 * @return servidor.roteamento.Caminho
	 * @roseuid 4262CADB0203
	 */
	public Collection conectarEsqueletos(Collection caminhos1, Collection caminhos2, int restricao) {
		Caminho caminhoPre, caminhoNovo;
		Collection caminhosRetorno = new ArrayList();
		VerticeSubMapa verticeAux;

		for (Iterator iter = caminhos1.iterator(); iter.hasNext();) {
			Caminho caminhoI = (Caminho) iter.next();
			for (Iterator iterator = caminhos2.iterator(); iterator.hasNext();) {
				Caminho caminhoJ = (Caminho) iterator.next();

				verticeAux = caminhoI.getFinal().getSubMapaPai();
				caminhoPre = verticeAux.caminhoPreCalculado(caminhoI.getFinal(), caminhoJ.getFinal(), restricao);
				if (caminhoPre != null) { // caminhos n�o est�o inclu�dos em submapas irm�os (caminhoPre � do tipo 2)
					System.out.println("ops");
					caminhoNovo = new Caminho(caminhoI);
					caminhoNovo.add(caminhoPre.getVertices(), caminhoPre.getCusto());
					caminhoNovo.unir(caminhoJ.getVertices(), caminhoJ.getCusto());
				} else {
					verticeAux = verticeAux.getSubMapaPai();
					caminhoPre = verticeAux.caminhoPreCalculado(caminhoI.getFinal(), caminhoJ.getFinal(), restricao);
					if (caminhoPre != null) { // caminhos est�o inclu�dos em submapas irm�os (caminhoPre � do tipo 3)
						caminhoNovo = new Caminho(caminhoI);
						caminhoNovo.add(caminhoPre.getVertices(), caminhoPre.getCusto());
						caminhoNovo.unir(caminhoJ.getVertices(), caminhoJ.getCusto());
					} else { // nenhum caminho pr� calculado dispon�vel (ERRO!)
						System.err.println("Erro! Faltou caminho pre calculado");
						return null;
					}
				}
				caminhosRetorno.add(caminhoNovo);
			}
		}
		return caminhosRetorno;
	}

	/**
	 * @param caminhos
	 * @return servidor.roteamento.Caminho
	 * @roseuid 4262CAF200BB
	 */
	public Caminho completarMelhorEsqueleto(Collection caminhos, int restricao) {
		Caminho melhorEsqueleto = new Caminho();
		melhorEsqueleto.add((Vertice) null, CUSTO_MAXIMO); // inicializar caminho com custo m�ximo
		for (Iterator iter = caminhos.iterator(); iter.hasNext();) {
			Caminho caminho = (Caminho) iter.next();
			if (caminho.getCusto() < melhorEsqueleto.getCusto()) {
				melhorEsqueleto = caminho;
			}
		}
		Caminho retorno = new Caminho();
		for (int i = 0; i < melhorEsqueleto.getVertices().size() - 1; i++) {
			
			Caminho temp = buscarCaminho(melhorEsqueleto.getVertice(i), melhorEsqueleto.getVertice(i + 1), restricao);
			if (temp == null) {
				Vertice temp1 = melhorEsqueleto.getVertice(i);
				Vertice temp2 = melhorEsqueleto.getVertice(i + 1);
				if (temp1 instanceof VerticePonte) {
					temp1 = temp1.getSubMapaPai().getGrafoQueContem().getVertice(temp1.getNome());
				}
				if (temp2 instanceof VerticePonte) {
					temp2 = temp2.getSubMapaPai().getGrafoQueContem().getVertice(temp2.getNome());
				}
				temp = buscarCaminho(temp1, temp2, restricao);
			}
			retorno.add(temp.getVertices(), temp.getCusto());
		}

		for (int i = 0; i < retorno.getVertices().size() - 1; i++) {
			while(retorno.getVertice(i).getNome().equals(retorno.getVertice(i + 1).getNome())) {
				retorno.getVertices().remove(i+1);
			}
		}

		// LIXO!!!
		// Caminho teste = new Caminho();
		// for (int i = 0; i < melhorEsqueleto.getVertices().size() - 1; i++) {
		// Vertice v = melhorEsqueleto.getVertice(i);
		// if (v.getNivelHierarquico() == 2) {
		// teste.add(v, 0);
		// } else if (v.getNivelHierarquico() == 1 && v instanceof
		// VerticeSubMapa) {
		// Grafo g = ((VerticeSubMapa)v).getSubGrafoContido();
		// Caminho temp = buscarCaminho(g.getVertice()
		// } else {
		//                
		// }
		// }

		return retorno;

	}

	/**
	 * @param verticeInicial
	 * @param vertices
	 * @roseuid 4262CB4701C5
	 */
	public Collection estimarCaminhos(Vertice verticeInicial, Collection vertices) {
		Collection caminhos = new ArrayList();
		for (Iterator iter = vertices.iterator(); iter.hasNext();) {
			Vertice vertice = (Vertice) iter.next();
			Caminho caminho = new Caminho();
			caminho.add(verticeInicial, 0);
			double custo = heuristica(verticeInicial, vertice);
			caminho.add(vertice, custo);
			caminhos.add(caminho);
		}
		return caminhos;
	}

	public double heuristica(Vertice origem, Vertice destino) {
		return origem.getLocalizacao().distancia(destino.getLocalizacao());
	}

	public void precalcularCaminhos() {

		for (Iterator iter = grafoHierarquico.iterator(); iter.hasNext();) {
			Grafo grafo = (Grafo) iter.next();
			if (grafo.getVerticeQueContem() != null) {
				Collection verticesPontes = grafo.getVerticeQueContem().getVerticesPontes();
				for (Iterator iteratorI = verticesPontes.iterator(); iteratorI.hasNext();) {
					Vertice verticeI = (Vertice) iteratorI.next();
					// Caso 1 - caminhos que ligam dois n�s pontes dentro de um grafo...
					for (Iterator iteratorJ = verticesPontes.iterator(); iteratorJ.hasNext();) {
						Vertice verticeJ = (Vertice) iteratorJ.next();
						if (verticeI != verticeJ) {
//							System.out.println("caso 1: " + verticeI.getNome() + ", " + verticeJ.getNome());
							// Calcula o caminho p/ cada restricao.
							for (int restricao = 0; restricao < MAXIMO_RESTRICOES; restricao++) {
								Caminho caminho = buscarCaminho(verticeI, verticeJ, restricao);
//								System.out.println(caminho);
								caminho.setRestricao(restricao);
								grafo.getVerticeQueContem().addCaminhoPreCalculado(caminho);
							}
						}
					}

					VerticeSubMapa paiVerticeI = verticeI.getSubMapaPai();

					if (paiVerticeI != null) {
						// Caso 3 - caminhos que ligam submapas irm�os contidos num grafo...
						for (Iterator iteratorJ = paiVerticeI.getGrafoQueContem().getVertices().iterator(); iteratorJ
								.hasNext();) {
							Vertice auxVerticeJ = (Vertice) iteratorJ.next();
							if (paiVerticeI != auxVerticeJ && auxVerticeJ instanceof VerticeSubMapa) {
								for (Iterator iterator = ((VerticeSubMapa) auxVerticeJ).getVerticesPontes().iterator(); iterator
										.hasNext();) {
									Vertice verticeJ = (Vertice) iterator.next();
									if (verticeI != verticeJ) {
										// Calcula o caminho p/ cada restricao.
//										System.out.println("caso 3: " + verticeI.getNome() + ", " + verticeJ.getNome());
										for (int restricao = 0; restricao < MAXIMO_RESTRICOES; restricao++) {
											Caminho temp = buscarCaminho(getVerticeCruzamento(verticeI.getNome()), getVerticeCruzamento(verticeJ.getNome()), restricao);
											Caminho caminho = completarCaminho(temp, restricao);
											//Caminho caminho = buscarCaminhoHierarquico(verticeI, verticeJ, restricao);
//											System.out.println(caminho);
											caminho.setRestricao(restricao);
											grafo.getVerticeQueContem().getSubMapaPai().addCaminhoPreCalculado(caminho);
										}
									}
								}
							}
						}
						// Caso 2 - caminhos que ligam os n�s pontes de um
						// submapa com os n�s de seu submapa pai...
//						for (Iterator iteratorJ = paiVerticeI.getVerticesPontes().iterator(); iteratorJ.hasNext();) {
//							Vertice verticeJ = (Vertice) iteratorJ.next();
//							if (verticeI != verticeJ) {
//								// Calcula o caminho p/ cada restricao.
//								System.out.println("caso 2: " + verticeI.getNome() + ", " + verticeJ.getNome());
//								for (int restricao = 0; restricao < MAXIMO_RESTRICOES; restricao++) {
//									Caminho caminho = buscarCaminhoHierarquico(verticeI, verticeJ, restricao);
//									System.out.println(caminho);
//									caminho.setRestricao(restricao);
//									grafo.getVerticeQueContem().addCaminhoPreCalculado(caminho);
//								}
//							}
//						}
					}
				}
			}
		}
	}

	// for (Iterator iter = grafoHierarquico.iterator(); iter.hasNext();) {
	// Grafo grafo = (Grafo) iter.next();
	// if (grafo.getVerticeQueContem() != null) {
	// Collection verticesPontes = grafo.getVerticeQueContem().getVerticesPontes();
	// for (Iterator iteratorI = verticesPontes.iterator(); iteratorI.hasNext();) {
	// Vertice verticeI = (Vertice) iteratorI.next();
	// // Caso 1 - caminhos que ligam dois n�s pontes dentro de um
	// // grafo...
	// for (Iterator iteratorJ = verticesPontes.iterator(); iteratorJ.hasNext();) {
	// Vertice verticeJ = (Vertice) iteratorJ.next();
	// if (verticeI != verticeJ) {
	// System.out.println("caso 1: " + verticeI.getNome() + ", " + verticeJ.getNome());
	// // Calcula o caminho p/ cada restricao.
	// for (int restricao = 0; restricao < MAXIMO_RESTRICOES; restricao++) {
	// Caminho caminho = buscarCaminho(verticeI, verticeJ, restricao);
	// System.out.println(caminho);
	// caminho.setRestricao(restricao);
	// grafo.getVerticeQueContem().addCaminhoPreCalculado(caminho);
	// }
	// }
	// }
	// VerticeSubMapa paiVerticeI = verticeI.getSubMapaPai();
	//
	// if (paiVerticeI != null) {
	// // Caso 3 - caminhos que ligam submapas irm�os contidos
	// // num grafo...
	// for (Iterator iteratorJ = paiVerticeI.getGrafoQueContem().getVertices().iterator(); iteratorJ
	// .hasNext();) {
	// Vertice auxVerticeJ = (Vertice) iteratorJ.next();
	// if (paiVerticeI != auxVerticeJ && auxVerticeJ instanceof VerticeSubMapa) {
	// for (Iterator iterator = ((VerticeSubMapa) auxVerticeJ).getVerticesPontes().iterator(); iterator
	// .hasNext();) {
	// Vertice verticeJ = (Vertice) iterator.next();
	// if (verticeI != verticeJ) {
	// // Calcula o caminho p/ cada restricao.
	// System.out.println("caso 3: " + verticeI.getNome() + ", " + verticeJ.getNome());
	// for (int restricao = 0; restricao < MAXIMO_RESTRICOES; restricao++) {
	// Caminho caminho = buscarCaminhoHierarquico(verticeI, verticeJ, restricao);
	// System.out.println(caminho);
	// caminho.setRestricao(restricao);
	// grafo.getVerticeQueContem().addCaminhoPreCalculado(caminho);
	// }
	// }
	// }
	// }
	// }
	// // Caso 2 - caminhos que ligam os n�s pontes de um
	// // submapa com os n�s de seu submapa pai...
	// for (Iterator iteratorJ = paiVerticeI.getVerticesPontes().iterator(); iteratorJ.hasNext();) {
	// Vertice verticeJ = (Vertice) iteratorJ.next();
	// if (verticeI != verticeJ) {
	// // Calcula o caminho p/ cada restricao.
	// System.out.println("caso 2: " + verticeI.getNome() + ", " + verticeJ.getNome());
	// for (int restricao = 0; restricao < MAXIMO_RESTRICOES; restricao++) {
	// Caminho caminho = buscarCaminhoHierarquico(verticeI, verticeJ, restricao);
	// System.out.println(caminho);
	// caminho.setRestricao(restricao);
	// grafo.getVerticeQueContem().addCaminhoPreCalculado(caminho);
	// }
	// }
	// }
	// }
	// }
	// }
	// }
	// }

	// //Caso 3 - caminhos que ligam submapas irm�os contidos num grafo...
	// Collection vertices = grafo.getVertices();
	// for (Iterator iteratorI = vertices.iterator(); iteratorI.hasNext();) {
	// Vertice verticeI = (Vertice) iteratorI.next();
	// if (verticeI instanceof VerticeSubMapa) {
	// for (Iterator iteratorJ = vertices.iterator(); iteratorJ.hasNext();) {
	// Vertice verticeJ = (Vertice) iteratorJ.next();
	// if (verticeI != verticeJ && verticeJ instanceof VerticeSubMapa) {
	// // Calcula o caminho p/ cada restricao.
	// for (int restricao = 0; restricao < MAXIMO_RESTRICOES; restricao++) {
	// Caminho caminho = buscarCaminho(verticeI, verticeJ, restricao);
	// caminho.setRestricao(restricao);
	// grafo.getVerticeQueContem().addCaminhoPreCalculado(caminho);
	// }
	// }
	// }
	// }
	// }

	/**
	 * @return Returns the grafoHierarquico.
	 */
	public Collection getGrafoHierarquico() {
		return grafoHierarquico;
	}

	public Vertice getVerticePonte(String nome) {
		for (Iterator iter = grafoHierarquico.iterator(); iter.hasNext();) {
			Grafo grafo = (Grafo) iter.next();
			for (Iterator iterator = grafo.getVertices().iterator(); iterator.hasNext();) {
				Vertice vertice = (Vertice) iterator.next();
				if (vertice instanceof VerticePonte && vertice.getNome().equalsIgnoreCase(nome)) {
					return vertice;
				}
			}
		}
		return null;
	}
	public Vertice getVerticeCruzamento(String nome) {
		for (Iterator iter = grafoHierarquico.iterator(); iter.hasNext();) {
			Grafo grafo = (Grafo) iter.next();
			for (Iterator iterator = grafo.getVertices().iterator(); iterator.hasNext();) {
				Vertice vertice = (Vertice) iterator.next();
				if (vertice instanceof VerticeCruzamento && vertice.getNome().equalsIgnoreCase(nome)) {
					return vertice;
				}
			}
		}
		return null;
	}
	
	public Caminho completarCaminho(Caminho caminho, int restricao) {
		Caminho caminhoRetorno = new Caminho();
		int i = 0;
		short estado = 1;
		while (i < caminho.getVertices().size()) {
			switch (estado) {
			case 1:
				Vertice v = caminho.getVertice(i);
				if (v.getNivelHierarquico() == 2) {
					caminhoRetorno.add(v, caminho.getVertice(i-1).getCustoPara(v, restricao));
					estado = 1;
				} else if (v.getNivelHierarquico() == 1) {
					caminhoRetorno.add(getVerticePonte(v.getNome()), 0);
					estado = 2;
				} else {
					System.err.println("ERRO!!!");
				}
				break;
			case 2:
				v = caminho.getVertice(i);
				if (v.getNivelHierarquico() == 2) {
					caminhoRetorno.add(v, 0);
					estado = 1;
				} else if (v.getNivelHierarquico() == 1) {
					if (v instanceof VerticeSubMapa) {
						Vertice vI = caminhoRetorno.getFinal();
						Vertice vF = getVerticePonte(caminho.getVertice(i + 1).getNome());
						Caminho c = buscarCaminho(vI, vF, restricao);
						caminhoRetorno.add(c.getVertices(), c.getCusto());
						estado = 2;
						i++;
					} else {
						caminhoRetorno.add(getVerticePonte(v.getNome()), caminho.getVertice(i-1).getCustoPara(v, restricao));
						estado = 2;
					}
				} else {
					System.err.println("ERRO!!!");
				}
				break;
			default:
				System.err.println("Nao deveria estar aqui! Estado inexistente!");
			}
			i++;
		}
		return caminhoRetorno;
	}
	// para funcionar com o BD descomente isto
	//public static void main(String[] args) throws SQLException {
	public static void main(String[] args) {

		Principal principal = new Principal();

		Grafo grafo = null;
		for (Iterator iter = principal.grafoHierarquico.iterator(); iter.hasNext();) {
			grafo = (Grafo) iter.next();
			if (grafo.getNome().equalsIgnoreCase("BlocoB1"))
				break;
		}
		Grafo grafo2 = null;
		for (Iterator iter = principal.grafoHierarquico.iterator(); iter.hasNext();) {
			grafo2 = (Grafo) iter.next();
			if (grafo2.getNome().equalsIgnoreCase("BlocoC1"))
				break;
		}
		Caminho caminhoDesejado = principal.buscarCaminhoHierarquico(grafo.getVertice("Entrada"), grafo2
				.getVertice("C1-70"), 0);
		System.out.println("\n\nCaminho Entrada -> C1-70");
		System.out.println("CAMINHO: " + caminhoDesejado);
		System.out.println("CUSTO: " + caminhoDesejado.getCusto());

		caminhoDesejado = principal
				.buscarCaminhoHierarquico(grafo2.getVertice("C1-70"), grafo.getVertice("Entrada"), 0);
		System.out.println("\n\nCaminho C1-70 -> Entrada");
		System.out.println("CAMINHO: " + caminhoDesejado);
		System.out.println("CUSTO: " + caminhoDesejado.getCusto());

		// // Teste caso 1 (v�rtices num mesmo submapa).
		// Grafo grafo = null;
		// for (Iterator iter = principal.grafoHierarquico.iterator();
		// iter.hasNext();) {
		// grafo = (Grafo) iter.next();
		// if (grafo.getNome().equalsIgnoreCase("Room 1W3"))
		// break;
		// }
		// Caminho caminhoDesejado =
		// principal.buscarCaminhoHierarquico(grafo.getVertice("Right bed 1"),
		// grafo
		// .getVertice("Bathroom 1"), 0);
		// System.out.println("CAMINHO: " + caminhoDesejado);
		// System.out.println("CUSTO: " + caminhoDesejado.getCusto());
		//
		// // Teste caso 2 (v�rtice inicial num n�vel mais profundo da
		// hierarquia)
		// Grafo grafo2 = null;
		// for (Iterator iter = principal.grafoHierarquico.iterator();
		// iter.hasNext();) {
		// grafo2 = (Grafo) iter.next();
		// if (grafo2.getNome().equalsIgnoreCase("West Section"))
		// break;
		// }
		// caminhoDesejado =
		// principal.buscarCaminhoHierarquico(grafo.getVertice("Right bed 1"),
		// grafo2
		// .getVertice("cross2"), 0);
		// System.out.println("CAMINHO2: " + caminhoDesejado);
		// System.out.println("CUSTO2: " + caminhoDesejado.getCusto());
		//
		// // Teste caso 4 (v�rtice inicial e final no mesmo n�vel da
		// hierarquia)
		// Grafo grafo3 = null;
		// for (Iterator iter = principal.grafoHierarquico.iterator();
		// iter.hasNext();) {
		// grafo3 = (Grafo) iter.next();
		// if (grafo3.getNome().equalsIgnoreCase("Room 2W3"))
		// break;
		// }
		// caminhoDesejado =
		// principal.buscarCaminhoHierarquico(grafo.getVertice("Right bed 1"),
		// grafo3
		// .getVertice("Bathroom 2"), 0);
		// System.out.println("CAMINHO3: " + caminhoDesejado);
		// System.out.println("CUSTO3: " + caminhoDesejado.getCusto());

	}
}